package com.nexus.core.exception;

import java.util.Collection;
import java.util.Map;
import java.util.Objects;

/**
 * 断言工具类（简化参数校验，如notNull()）
 *
 * @Date 2025/7/23 14:22
 * @Author luzhengning
 **/
public class Assert {
    /**
     * 断言表达式为true，否则抛出IllegalArgumentException
     *
     * @param expression 布尔表达式
     * @param message    异常信息
     */
    public static void isTrue(boolean expression, String message) {
        if (!expression) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言表达式为true，否则抛出IllegalArgumentException（默认消息）
     *
     * @param expression 布尔表达式
     */
    public static void isTrue(boolean expression) {
        isTrue(expression, "表达式必须为true");
    }

    /**
     * 断言表达式为false，否则抛出IllegalArgumentException
     *
     * @param expression 布尔表达式
     * @param message    异常信息
     */
    public static void isFalse(boolean expression, String message) {
        if (expression) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言对象为null，否则抛出IllegalArgumentException
     *
     * @param object  待检查对象
     * @param message 异常信息
     */
    public static void isNull(Object object, String message) {
        if (object != null) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言对象不为null，否则抛出NullPointerException
     *
     * @param object  待检查对象
     * @param message 异常信息
     */
    public static void notNull(Object object, String message) {
        if (object == null) {
            throw new NullPointerException(message);
        }
    }

    /**
     * 断言对象不为null，否则抛出NullPointerException（默认消息）
     *
     * @param object 待检查对象
     */
    public static void notNull(Object object) {
        notNull(object, "对象不能为null");
    }

    /**
     * 断言字符串不为null且不为空（去除首尾空格后），否则抛出IllegalArgumentException
     *
     * @param text    待检查字符串
     * @param message 异常信息
     */
    public static void hasText(String text, String message) {
        if (text == null || text.trim().isEmpty()) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言字符串不为null且不为空（去除首尾空格后），否则抛出IllegalArgumentException（默认消息）
     *
     * @param text 待检查字符串
     */
    public static void hasText(String text) {
        hasText(text, "字符串不能为null或空");
    }

    /**
     * 断言集合不为null且不为空，否则抛出IllegalArgumentException
     *
     * @param collection 待检查集合
     * @param message    异常信息
     */
    public static void notEmpty(Collection<?> collection, String message) {
        notNull(collection, message);
        if (collection.isEmpty()) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言集合不为null且不为空，否则抛出IllegalArgumentException（默认消息）
     *
     * @param collection 待检查集合
     */
    public static void notEmpty(Collection<?> collection) {
        notEmpty(collection, "集合不能为null或空");
    }

    /**
     * 断言Map不为null且不为空，否则抛出IllegalArgumentException
     *
     * @param map     待检查Map
     * @param message 异常信息
     */
    public static void notEmpty(Map<?, ?> map, String message) {
        notNull(map, message);
        if (map.isEmpty()) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言数组不为null且长度大于0，否则抛出IllegalArgumentException
     *
     * @param array   待检查数组
     * @param message 异常信息
     */
    public static void notEmpty(Object[] array, String message) {
        notNull(array, message);
        if (array.length == 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言两个对象相等（使用Objects.equals()），否则抛出IllegalArgumentException
     *
     * @param expected 预期对象
     * @param actual   实际对象
     * @param message  异常信息
     */
    public static void equals(Object expected, Object actual, String message) {
        if (!Objects.equals(expected, actual)) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言数值大于0，否则抛出IllegalArgumentException
     *
     * @param number  待检查数值
     * @param message 异常信息
     */
    public static void greaterThanZero(Number number, String message) {
        notNull(number, message);
        if (number.doubleValue() <= 0) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 断言两个对象属于同一类型，否则抛出IllegalArgumentException
     *
     * @param obj     待检查对象
     * @param clazz   预期类型
     * @param message 异常信息
     */
    public static void isInstanceOf(Object obj, Class<?> clazz, String message) {
        notNull(clazz, "类型不能为null");
        if (!clazz.isInstance(obj)) {
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * 直接抛出异常，用于标记不应该执行到的代码
     *
     * @param message 异常信息
     */
    public static void shouldNotReachHere(String message) {
        throw new IllegalStateException("不应该执行到此处: " + message);
    }
}